import datetime

from flask import Response, jsonify, Flask, request, Blueprint,url_for
from configs import *
from modules.Tables import *




# 创建蓝图，对应的register目录
user_view = Blueprint('user_view', __name__)


# 登录接口获取token
@user_view.route('/login', methods=['GET'])
# @jwt_required()
def login():

    username = request.args.get('username', None)
    password = request.args.get('password', None)

    # 去除用户名和密码中的首尾空格
    username = username.strip() if username else None
    password = password.strip() if password else None

    if username is None or password is None:
        return jsonify({"msg": "用户名或者密码为空！",'code':400})

    # 尝试查询用户信息  (当没有数据的时候返回值为 None)
    user_info = db.session.query(User).filter(User.username == username).first()

    if user_info is None:
        return jsonify({"msg": "用户名或密码错误",'code':401})

    if user_info.user_status == '0':
        return jsonify({"msg": "账号禁用！", 'code': 400})

    # if not validate_password_complexity(password):
    #     return jsonify({"msg" : "密码不符合复杂度要求", 'code' : 400})

    # 如果用户名存在验证密码
    if user_info and password_decryption(password,user_info.password):

        # 最后登录时间修改
        user_info.end_login_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        db.session.commit()

        query = db.session.query(
            User.id,
            User.name,
            User.username,
            User.user_status,
            User.create_time,
            User.end_login_time,
            # 将同一用户的多个权限组合成一个逗号分隔的字符串
            func.group_concat(Permission.permission_name.distinct()).label('permissions_name'),
            func.group_concat(Permission.id.distinct()).label('role_id')
        ).join(UserPermission, User.id == UserPermission.user_id) \
            .join(Permission, UserPermission.permission_id == Permission.id) \
            .group_by(User.id, User.name, User.username, User.user_status, User.create_time,
                      User.end_login_time).filter(User.id==user_info.id).first()

        # token返回
        access_token = create_access_token(identity=username)
        return jsonify({
            'code':200,
            'msg':'登录成功！',
            'access_token': access_token,
            'user_id': user_info.id,
            'user_role_name':query.permissions_name,
            'user_role_id':query.role_id,
            'datatime_time': datetime.now().strftime("%Y-%m-%d %H:%M"),

        })
    else:
        # 登录失败，返回错误响应
        return jsonify({"msg" :"用户名或密码错误",'code': 401})

# token验证  如果失效 前端回退到登录页面
@user_view.route('/token_refresh', methods=['GET'])
# @jwt_required()
def token_refresh():
    username = request.args.get('username')
    access_token = create_access_token(identity=username)
    return jsonify({"access_token" : access_token})


# token验证  如果失效 前端回退到登录页面
@user_view.route('/protected', methods=['GET', 'POST', 'DELETE', 'PUT', 'CATCH'])
# @jwt_required()
def protected():

    # token验证  成功返回信息
    current_user = get_jwt_identity()

    # 查找token对应用户信息返回
    user_info = db.session.query(User).filter(User.username == current_user).first()

    # 获取用户多权限数据
    permission_data = db.session.query(User.id,User.username,Permission.id.label('userpermission_id'),Permission.permission_name,).join(UserPermission,User.id == UserPermission.user_id).\
        join(Permission,UserPermission.permission_id == Permission.id).filter(User.id == user_info.id).all()

    permission_data = [{'permission_id':i.userpermission_id,'permission_name':i.permission_name} for i in permission_data]

    # 序列化
    user_data = convert_folder_to_dict_list(user_info, ['id','username', 'email', 'create_time'])

    # dict数据拼接
    user_data = {**user_data, **{'permission_data':permission_data}}


    return jsonify({
        'logged_in_as': current_user,
        'code':200,
        'user_info': user_data
    })


# 用户注册接口
@user_view.route('/register', methods=['POST'])
def register():

    # 接受所传参数用户信息
    username = request.form.get('username', None)
    name = request.form.get('name', None)
    password = request.form.get('password', None)

    # 去除用户名和密码中的首尾空格
    username = username.strip() if username else None
    password = password.strip() if password else None

    if username is None or password is None:
        return jsonify({
            'code': 400,
            'msg': '用户名和密码必须提供！'
        })

    if not validate_password_complexity(password):
        return jsonify({
            'code': 400,
            'msg': '密码不符合复杂度要求！'
        })

    # 查找用户名称相同用户
    user = db.session.query(User).filter(User.username == username).first()

    if user:
        return jsonify({
            'code': 400,
            'msg': '该用户已经存在！'
        })

    # 创建新用户并将加密后的密码存储到数据库
    new_user = User(username=username, password=password_encryption(password),name=name,user_status=1)
    db.session.add(new_user)
    db.session.commit()

    return jsonify({
            'code': 200,
            'msg': '注册成功！',
    })


# 用户信息展示接口（用户管理）
@user_view.route('/user_data_manage', methods=['GET'])
@jwt_required()
@jwt_required_with_refresh
def user_data_manage():


    name = request.args.get('name',None)  # 用户搜索
    username = request.args.get('username',None) # 账号搜索
    user_status = request.args.get('user_status',1) # 启用状态搜索 1启用 0 禁用

    # 定义筛选列表
    filters = []
    # 当筛选条件存在用户时添加到列表
    if name:
        filters.append(User.name.like(f"%{name}%"))
    # 当筛选条件存在账号时添加到列表
    if username:
        filters.append(User.username.like(f"%{username}%"))
    # 当筛选条件存在用户状态时添加到列表
    if user_status:
        filters.append(User.user_status == user_status)

    # 构建 query_filter 组合条件
    query_filter = and_(*filters) if filters else None

    # 获取分页参数
    page = request.args.get('page', default=1, type=int)  # 当前页码
    per_page = request.args.get('per_page', default=15, type=int)  # 每页条数

    # 连表查询用户与用户权限表，获取所需数据
    query = db.session.query(
        User.id,
        User.name,
        User.username,
        User.user_status,
        User.create_time,
        User.end_login_time,
        # 将同一用户的多个权限组合成一个逗号分隔的字符串
        func.group_concat(Permission.permission_name.distinct()).label('permissions_name')
    ).join(UserPermission, User.id == UserPermission.user_id) \
        .join(Permission, UserPermission.permission_id == Permission.id) \
        .group_by(User.id, User.name, User.username, User.user_status, User.create_time,
                  User.end_login_time)

    # 检查是否有筛选条件
    if filters:
        query = query.filter(and_(*filters))

    # 分页查询
    pagination = query.paginate(page=page, per_page=per_page, error_out=False)

    # 获取当前页的数据
    user_permission_datalist = pagination.items

    # 将结果转换为字典列表
    user_permission_datalist = convert_folder_to_dict_list(user_permission_datalist, ['id', 'name', 'username', 'permissions_name', 'user_status', 'create_time', 'end_login_time'])

    # 返回分页结果
    return jsonify({
        'code': 200,
        'data': user_permission_datalist,
        'total_items': pagination.total,
        'total_pages': pagination.pages,
        'current_page': pagination.page,
        'per_page': pagination.per_page,
    })



# 用户信息添加接口（用户管理）
@user_view.route('/user_data_manage_add', methods=['POST'])
@jwt_required()
@jwt_required_with_refresh
def user_data_manage_add():
    """
    用户信息添加接口
    """

    # 获取请求参数
    name = request.form.get('name', None)
    username = request.form.get('username', None)
    password = request.form.get('password', None)
    email = request.form.get('email', None)
    permission_list_id = request.form.get('permission_list_id', '[]')

    # 检查是否提供了必要的用户信息
    if not all([name, username, email,password]):
        return jsonify({'code': 400, 'msg': '用户姓名、用户名和邮箱为必填项！'})

    # 检查传入的权限ID列表
    try:
        permission_list_id = eval(permission_list_id)
        new_permissions = set(permission_list_id)  # 转换为集合进行集合运算
    except Exception as e:
        return jsonify({'code': 400, 'msg': f'权限列表数据解析错误: {str(e)}'})

    # 创建新的用户记录
    new_user = User(name=name, username=username,password=password_encryption(password),email=email)

    try:
        # 将新用户添加到数据库会话
        db.session.add(new_user)
        db.session.commit()  # 提交以获取新用户的ID
        user_id = new_user.id

        # 添加用户权限到UserPermission表
        if new_permissions:
            new_user_permissions = [
                UserPermission(user_id=user_id, permission_id=perm_id)
                for perm_id in new_permissions
            ]
            db.session.bulk_save_objects(new_user_permissions)  # 批量保存用户权限

        # 提交事务
        db.session.commit()
        print(f"添加权限 {new_permissions} 给用户 {user_id}")

        return jsonify({'code': 200, 'msg': '用户添加成功！'})

    except Exception as e:
        # 发生异常时回滚事务
        db.session.rollback()
        return jsonify({'code': 500, 'msg': f'用户添加失败: {str(e)}'})


# 用户信息修改接口（用户管理）
@user_view.route('/user_data_manage_write', methods=['POST'])
@jwt_required()
@jwt_required_with_refresh
def user_data_manage_write():
    """
    用户信息修改接口
    """

    # 获取请求参数
    user_id = request.form.get('user_id', None)
    name = request.form.get('name', None)
    username = request.form.get('username', None)
    email = request.form.get('email', None)
    permission_list_id = request.form.get('permission_list_id', '[]')

    # 检查用户ID是否存在
    if not user_id:
        return jsonify({'code': 400, 'msg': '用户ID未提供！'})

    # 获取用户信息
    user_info = db.session.query(User).filter(User.id == user_id).first()
    if not user_info:
        return jsonify({'code': 404, 'msg': '用户不存在！'})

    # 更新用户基本信息
    if name:
        user_info.name = name
    if username:
        user_info.username = username
    if email:
        user_info.email = email

    # 查询用户当前拥有的权限ID列表
    current_permissions = db.session.query(UserPermission.permission_id).filter(UserPermission.user_id == user_id).all()
    current_permissions = {perm_id for perm_id, in current_permissions}  # 将结果转换为集合

    # 检查传入的权限ID列表
    try:
        permission_list_id = eval(permission_list_id)
        new_permissions = set(permission_list_id)  # 转换为集合进行集合运算
    except Exception as e:
        return jsonify({'code': 400, 'msg': f'权限列表数据解析错误: {str(e)}'})

    # 计算需要添加和删除的权限
    to_add = new_permissions - current_permissions
    to_delete = current_permissions - new_permissions

    # 删除不再需要的权限
    if to_delete:
        db.session.query(UserPermission).filter(
            UserPermission.user_id == user_id,
            UserPermission.permission_id.in_(to_delete)
        ).delete(synchronize_session=False)
        print(f"删除权限 {to_delete} 从用户 {user_id}")

    # 添加新的权限
    if to_add:
        new_user_permissions = [UserPermission(user_id=user_id, permission_id=perm_id) for perm_id in to_add]
        db.session.bulk_save_objects(new_user_permissions)
        print(f"添加权限 {to_add} 给用户 {user_id}")

    # 提交事务
    try:
        db.session.commit()
        return jsonify({'code': 200, 'msg': '用户信息和权限更新成功！'})
    except Exception as e:
        db.session.rollback()  # 回滚事务
        return jsonify({'code': 500, 'msg': f'数据库提交失败: {str(e)}'})


# 用户密码修改接口（用户管理）
@user_view.route('/user_password_modification', methods=['POST'])
@jwt_required()
@jwt_required_with_refresh
def user_password_modification():
    """
    用户密码修改接口
    """

    # 获取请求参数
    user_id = request.form.get('user_id', None)
    current_password = request.form.get('current_password', None)
    new_password = request.form.get('new_password', None)
    password_confirm = request.form.get('password_confirm', None)

    # 获取用户信息
    user_info = db.session.query(User).filter(User.id == user_id).first()
    if user_info:
        if password_decryption(current_password,user_info.password):
            if new_password:
                if not validate_password_complexity(new_password):
                    return jsonify({
                        'code': 400,
                        'msg': '密码不符合复杂度要求！'
                    })
                if new_password == password_confirm:
                    user_info.password = password_encryption(new_password)
                    db.session.commit()
                    return jsonify({'code': 200, 'msg': '密码修改成功！'})
                else:
                    return jsonify({'code': 400, 'msg': '两次输入的新密码不一致！'})
            else:
                return jsonify({'code': 400, 'msg': '请输入新密码！'})
        else:
            return jsonify({'code': 400, 'msg': '旧密码不正确！'})


# 用户启用状态修改接口（用户管理）
@user_view.route('/user_data_manage_status_update', methods=['POST'])
@jwt_required()
@jwt_required_with_refresh
def user_data_manage_status_update():
    # 用户启用状态  1启用 2禁用
    status = request.form.get('user_status',1)
    # 用户id
    user_id = request.form.get('user_id',None)
    # 当用户id与用户状态存在
    if user_id and status:
        # 查询用户相同并且修改状态
        db.session.query(User).filter(User.id==user_id).update({'user_status':status})
        # 数据提交
        db.session.commit()
        return jsonify({'code':200, 'message':'用户状态修改成功'})
    return jsonify({'code':400, 'message':'用户及状态未输入'})


# 用户信息详情获取（用户管理）
@user_view.route('/user_data_manage_detile', methods=['GET'])
@jwt_required()
@jwt_required_with_refresh
def user_data_manage_detile():

    # 用户id
    user_id = request.args.get('user_id',None)
    # 第几页
    page = request.args.get('page', default=1, type=int)
    # 每页条数
    per_page = request.args.get('per_page', default=15, type=int)

    # 查询用户详情
    user_data_manage = db.session.query(
        User.id,
        User.name,
        User.username,
        User.password,
        User.email,
        # 函数将同一用户的多个权限组合成一个逗号分隔的字符串。
        func.group_concat(UserPermission.permission_id).label('permissions_ids')  # 将权限合并为一个字符串
    ).join(UserPermission,User.id == UserPermission.user_id).filter(User.id==user_id).paginate(page=page, per_page=per_page, error_out=False)

    # 构建返回的 JSON
    response_data = {
        'total_items': user_data_manage.total,
        'total_pages': user_data_manage.pages,
        'current_page': user_data_manage.page,
        'per_page': per_page,
            'data': [
        {'id': i.id, 'name': i.name, 'username': i.username, 'permissions_ids': i.permissions_ids}
        for i in user_data_manage.items
    ]
    }

    return jsonify({'code': 200, 'data': response_data,'msg':'查询成功'})


# 权限相关筛选接口
@user_view.route('/permission_menu_select', methods=['GET'])
@jwt_required()
@jwt_required_with_refresh
def permission_menu_select():

    # 角色列表返回
    permission_data = convert_folder_to_dict_list(db.session.query(Permission).all(),['id','permission_name','permission_content','permission_status','permission_code','created_at'])
    # 菜单列表返回
    menu_list = [{
        'menu_id':i.id,'menu_name':i.menu_name,'menu_link':i.menu_link,'menu_icon':i.menu_icon,'menu_status':i.menu_status,
        'menu_order':i.menu_order,'menu_parent_id':i.menu_parent_id,'permissions_list':[],
                  } for i in db.session.query(Menu).all()]

    # 自定义排序函数  按照菜单表自定义顺序来对菜单进行排序
    def custom_sort(menu):
        return menu.get('menu_order', 0)

    # 对菜单项列表进行排序
    sorted_menu_items = sorted(menu_list, key=custom_sort)

    # 从 menu_parent_id为none主节点开始找  （递归找出所有子类菜单）
    def build_tree(data, parent_id=None):
        tree = []
        for item in data:
            if item['menu_parent_id'] == parent_id:
                children = build_tree(data, item['menu_id'])
                if children:
                    item['children'] = children
                tree.append(item)
        return tree

    # 调用方法获取父子菜单组装数据
    menu_list = build_tree(sorted_menu_items)

    data_list = {
        'permission_data':permission_data,
        'menu_list':menu_list,
                }
    return jsonify({'code': 200, 'data': data_list})



# 用户删除（用户管理）
@user_view.route('/user_data_manage_delete', methods=['POST'])
@jwt_required()
@jwt_required_with_refresh
def user_data_manage_delete():
    """
    删除用户数据

    参数:
        user_id (str): 要删除的用户ID
    返回:
        json: 响应结果，包含状态码和消息
    """
    # 获取用户ID
    user_id = request.form.get('user_id', None)

    if not user_id:
        return jsonify({'code': 400, 'message': '用户ID缺失!'})

    # 查找对应用户数据
    user_data = db.session.query(User).filter(User.id == user_id).first()

    if not user_data:
        return jsonify({'code': 404, 'message': '用户不存在!'})

    try:
        # 删除用户数据
        db.session.delete(user_data)

        # 提交事务
        db.session.commit()
        return jsonify({'code': 200, 'message': '用户删除成功!'})

    except Exception as e:
        # 捕获异常并回滚事务
        db.session.rollback()
        return jsonify({'code': 500, 'message': f'删除用户时发生错误: {str(e)}'})



